home *** CD-ROM | disk | FTP | other *** search
/ Aminet 6 / Aminet 6 - June 1995.iso / Aminet / misc / sci / RARS_Amiga_2.lha / RARS / cntrlb0.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  1995-03-31  |  4.0 KB  |  128 lines
  1. // CNTRLb0.CPP - "driver" function for RARS 
  2. // By Bill Benedict, Feb. 1995
  3. // This driver is much better than bill.cpp, even if it is slower ;)
  4. // I haven't worked to much on making this one as fast as bill.cpp, but
  5. // it makes up its time in handling traffic much better.  In tests, bill.cpp
  6. // will lap this driver after 100 laps or so, but in a 200 lap race with
  7. // 8 different cars, bill.cpp was down by 2 laps at the end :)
  8. // This driver is also heavily modified from the fast 'Kernign' driver.
  9. // This is also my 'working' copy, so there are various bits of code
  10. // that were added and/or commented out along the way.  Feel free to
  11. // play with and modify this all you want :)
  12. // (see CNTRL0.CPP for better comments)
  13. // adapted to ver. 0.39 3/6/95 by M. Timin
  14.  
  15. #include <string.h>
  16. #include <stdlib.h>
  17. #include <math.h>
  18. #include "car.h"
  19.  
  20. extern double width;
  21. extern const double CARWID;
  22. extern char* glob_name;
  23.  
  24. con_vec cntrlb0(situation s)
  25. {
  26.    const char name[] = "BillyB1";
  27.    static int init_flag = 1;
  28.    con_vec result;
  29.    double alpha, vc, rad;
  30.    double steer_gain = .2;
  31.    const double steer_damp = .48;
  32.    const double normalane = 30.0;
  33.    static double vc_mult = 1.0;
  34.    static int lane_time = 0;
  35.    static int lane_time2 = 0;
  36.    static int lane_change = -15;
  37.    static double lane = 30;    // determines right-left position on straigtaway
  38.    const double corn_con = 6.8;
  39.    static double corn_spd = 68.0;
  40.  
  41.    if(init_flag)  {
  42.       strcpy(glob_name, name);
  43.       init_flag = 0;
  44.       result.alpha = result.vc = 0;
  45.       return result;
  46.    }
  47.  
  48.   if(stuck(s.backward, s.v,s.vn, s.to_lft,s.to_rgt, &result.alpha,&result.vc))
  49.       return result;
  50.  
  51.    if(s.cur_rad == 0.0 && s.nex_rad != 0.0)
  52.       corn_spd = corn_con * sqrt(s.nex_rad > 0.0 ? s.nex_rad : -s.nex_rad);
  53.    else
  54.       corn_spd = corn_con * sqrt(s.cur_rad > 0.0 ? s.cur_rad : -s.cur_rad);
  55.  
  56.    // maybe choose a different lane: (to help in passing)
  57.    if(!s.dead_ahead) {
  58.       if (lane_time <= 0) {
  59.     lane_time=-1;
  60.     lane = normalane+45; //+ random(5)*15;
  61.       }
  62.    }
  63.    else if (lane_time2 <= 0){
  64.       // pick a different lane:
  65.       if(lane >= 75)               // pick a new lane somehow:
  66.      lane_change = -15;
  67.       else if(lane <= -75)
  68.      lane_change = 15;
  69.       lane += lane_change;
  70.       if (lane > 90) lane = 90;
  71.       else if (lane < -90) lane = -90;
  72.       lane_time2=20;
  73.       lane_time=100;
  74.    }
  75.    if (lane_time >=0 ){
  76.      lane_time--;
  77.      lane_time2--;
  78.    }
  79. // Audible buzz when the dead_ahead flag is set for this driver
  80. //if(s.dead_ahead) {sound(20);delay(2);nosound();}
  81.    vc_mult=1.0;
  82.  
  83.    if((s.cur_rad == 0) && ((s.to_end/s.cur_len > .2) || (s.v < corn_spd*.8))) {
  84.       // in the straight-away and not speeding near a turn
  85.       alpha = .25 * steer_gain * (s.to_lft - s.to_rgt - lane) / width;
  86.       if(s.dead_ahead)
  87.       alpha *= 4.0;
  88.     }
  89.    else {
  90.       if(s.cur_rad == 0) {
  91.     rad=s.nex_rad;
  92.     vc_mult = (s.to_lft < (width/2) ? (1.25-s.to_rgt/(2*width)) : 1.0);
  93.       }
  94.       else rad=s.cur_rad;
  95.  
  96.       if(rad > 0.0)   {
  97.     alpha = steer_gain * (3 * (s.to_lft -
  98.              (s.nex_rad < 0.0 ? width/3 : 1.6*CARWID)) / width +
  99.              (s.cur_rad == 0 ? 0 : .05 * width/s.to_rgt));
  100. //      if(s.dead_ahead)
  101. //   alpha *= .7;
  102.  
  103.       }
  104.       else  {
  105.     alpha = -steer_gain * (3 * (s.to_rgt -
  106.              (s.nex_rad > 0.0 ? width/3 : 1.6*CARWID)) / width +
  107.              (s.cur_rad == 0 ? 0 :.05 * width/s.to_lft));
  108. //      if(s.dead_ahead)
  109. //   alpha *= .7;
  110.       }
  111.    }
  112.    alpha -= steer_damp * s.vn / s.v;  // This is damping, to prevent oscillation
  113.  
  114.    if(s.cur_rad == 0)         // If we are on a straightaway,
  115.       if(s.to_end/s.cur_len > .13)      // if we are far from the end:
  116.      vc = s.v + 85/s.v;        // keep accellerating near full power
  117.       else  {                 // otherwise,
  118.      vc = corn_spd;           // maintain cornering speed, braking at first
  119.      // this next formula will not work if a rt. turn follows the straight:
  120. //   alpha += .4 * (s.cur_len/(s.to_end + s.cur_len) - (1/1.25 ));
  121.       }
  122.    else            // if we're in the curve, maintain speed, +
  123.       vc = corn_spd + 1.2 / (s.to_end + .6);
  124.  
  125.    result.vc = vc*vc_mult;   result.alpha = alpha;
  126.    return result;
  127. }                                                              // v;
  128.